home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / More Source / C⁄C++ / Peter's Final Project / sys / sys.stuff.c < prev    next >
Text File  |  1995-05-10  |  8KB  |  486 lines
  1. /*
  2.  *  Peter's Final Project -- A texture mapping demonstration
  3.  *  © 1995, Peter Mattis
  4.  *
  5.  *  E-mail:
  6.  *  petm@soda.csua.berkeley.edu
  7.  *
  8.  *  Snail-mail:
  9.  *   Peter Mattis
  10.  *   557 Fort Laramie Dr.
  11.  *   Sunnyvale, CA 94087
  12.  *
  13.  *  Avaible from:
  14.  *  http://www.csua.berkeley.edu/~petm/final.html
  15.  *
  16.  *  This program is free software; you can redistribute it and/or modify
  17.  *  it under the terms of the GNU General Public License as published by
  18.  *  the Free Software Foundation; either version 2 of the License, or
  19.  *  (at your option) any later version.
  20.  *
  21.  *  This program is distributed in the hope that it will be useful,
  22.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  23.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24.  *  GNU General Public License for more details.
  25.  *
  26.  *  You should have received a copy of the GNU General Public License
  27.  *  along with this program; if not, write to the Free Software
  28.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29.  */
  30.  
  31. #include <MacHeaders>
  32. #include <Palettes.h>
  33. #include <QDOffscreen.h>
  34.  
  35. #include <assert.h>
  36. #include <ctype.h>
  37. #include <stdio.h>
  38. #include <string.h>
  39.  
  40. #include "sys.stuff.h"
  41. #include "utils.h"
  42.  
  43. static void do_sys_init_graphics(void);
  44. static void do_sys_end_graphics(void);
  45. static void do_sys_create_window(void);
  46.  
  47. static void do_update_screen8(void);
  48. static void do_update_screen24(void);
  49. static void do_clear_frame_buffer8(void);
  50. static void do_clear_frame_buffer24(void);
  51.  
  52. static long default_size = 200;
  53. static long default_depth = 8;
  54. static long default_pixel = 1;
  55.  
  56. static CWindowPtr win;
  57. static PaletteHandle palette;
  58. static void *image_mem;
  59. static void *screen_mem;
  60. static long screen_width;
  61. static long screen_height;
  62.  
  63. static PIXEL8 color8;
  64. static PIXEL24 color24;
  65.  
  66. static short mode = 1;
  67.  
  68. static EVENT_HANDLER event_handler;
  69.  
  70. void
  71. do_set_window_size(size)
  72. short size;
  73. {
  74.     default_size = size;
  75. }
  76.  
  77. void
  78. do_set_depth(depth)
  79. short depth;
  80. {
  81.     default_depth = depth;
  82.  
  83.     if ((default_depth != 8) && (default_depth != 24))
  84.         fatal_error ("Invalid display size %d", default_depth);
  85.  
  86.     switch (default_depth)
  87.     {
  88.     case 8:
  89.         default_pixel = 1;
  90.         break;
  91.     case 24:
  92.         default_pixel = 4;
  93.         break;
  94.     }
  95. }
  96.  
  97. void
  98. do_set_mode (m)
  99. short m;
  100. {
  101.     mode = m;
  102. }
  103.  
  104. void
  105. do_set_event_handler(handler)
  106. EVENT_HANDLER handler;
  107. {
  108.     event_handler = handler;
  109. }
  110.  
  111. void
  112. do_sys_init()
  113. {
  114.     do_sys_init_graphics();
  115.     do_sys_create_window();
  116. }
  117.  
  118. void
  119. do_sys_exit()
  120. {
  121.     do_sys_end_graphics();
  122. }
  123.  
  124. static void
  125. do_sys_init_graphics()
  126. {
  127.     MaxApplZone();
  128.  
  129.     InitGraf((Ptr) &qd.thePort);
  130.     InitFonts();
  131.     InitWindows();
  132.     InitMenus();
  133.     FlushEvents(everyEvent, 0);
  134.     TEInit();
  135.     InitDialogs(0L);
  136.     InitCursor();
  137. }
  138.  
  139. static void
  140. do_sys_end_graphics()
  141. {
  142.     DisposeWindow((WindowPtr) win);
  143.     FlushEvents(everyEvent, 0);
  144. }
  145.  
  146. static void
  147. do_sys_create_window()
  148. {
  149.     GDHandle gdev;
  150.     Rect r, *bounds;
  151.     char *screen_addr;
  152.     CTabHandle ctab;
  153.  
  154.     SetRect(&r, 0, 20, 0 + default_size, 20 + default_size);
  155.     win = (CWindowPtr) NewCWindow(nil, &r, "\p", false, plainDBox, (WindowPtr) - 1, 0, 0);
  156.     ShowWindow((WindowPtr) win);
  157.     SetPort((WindowPtr) win);
  158.  
  159.     ctab = GetCTable(128);
  160.     assert(ctab != NULL);
  161.  
  162.     palette = NewPalette((**ctab).ctSize + 1, ctab, pmAnimated + pmExplicit, 0);
  163.     NSetPalette((WindowPtr) win, palette, pmFgUpdates);
  164.  
  165.     DisposeCTable(ctab);
  166.  
  167.     PmForeColor(1);
  168.     PaintRect(&win->portRect);
  169.  
  170.     bounds = &(*(win->portPixMap))->bounds;
  171.     screen_width = (*(win->portPixMap))->rowBytes & 0x7FFF;
  172.     screen_height = 0;
  173.     screen_addr = GetPixBaseAddr(win->portPixMap) + 
  174.         (screen_width * -bounds->top) - bounds->left;
  175.     screen_mem = screen_addr;
  176.  
  177.     image_mem = ALLOC(default_pixel * default_size * default_size);
  178.     assert(image_mem != NULL);
  179. }
  180.  
  181. void
  182. do_sys_event()
  183. {
  184.     static char key_down[6] = { 
  185.         0, 0, 0, 0, 0     };
  186.     static char key_part[6] = { 
  187.         1, 1, 3, 3, 3, 3     };
  188.     static long key_val[6] = { 
  189.         ESC_KEY, TAB_KEY, LEFT_KEY, RIGHT_KEY, UP_KEY, DOWN_KEY     };
  190.     static long key_mask[6] = 
  191.         { 
  192.         0x00002000, 0x00000100, 0x00000008, 0x00000010, 0x00000040, 0x00000020     };
  193.  
  194.     KeyMap keys;
  195.     long event_type;
  196.     long val;
  197.     short i;
  198.  
  199.     GetKeys(keys);
  200.  
  201.     for (i = 0; i < 6; i++)
  202.     {
  203.         if (keys[key_part[i]] & key_mask[i])
  204.         {
  205.             val = key_val[i];
  206.             event_type = KEY_PRESS_EVENT;
  207.             if (!key_down[i] && event_handler)
  208.             {
  209.                 key_down[i] = 1;
  210.                 (*event_handler) (event_type, val);
  211.             }
  212.         }
  213.         else if (key_down[i])
  214.         {
  215.             key_down[i] = 0;
  216.             val = key_val[i];
  217.             event_type = KEY_RELEASE_EVENT;
  218.             if (event_handler)
  219.                 (*event_handler) (event_type, val);
  220.         }
  221.     }
  222. }
  223.  
  224. void*
  225. do_sys_read_graphic_file(file_name, width, height)
  226. char *file_name;
  227. long *width;
  228. long *height;
  229. {
  230.     return NULL;
  231. }
  232.  
  233. void
  234. do_update_screen()
  235. {
  236.     switch (default_depth)
  237.     {
  238.     case 8:
  239.         do_update_screen8();
  240.         break;
  241.     case 24:
  242.         do_update_screen24();
  243.         break;
  244.     }
  245. }
  246.  
  247. void 
  248. do_clear_frame_buffer()
  249. {
  250.     switch (default_depth)
  251.     {
  252.     case 8:
  253.         do_clear_frame_buffer8();
  254.         break;
  255.     case 24:
  256.         do_clear_frame_buffer24();
  257.         break;
  258.     }
  259. }
  260.  
  261. void
  262. do_set_color(c)
  263. long c;
  264. {
  265.     switch (default_depth)
  266.     {
  267.     case 8:
  268.         color8 = c;
  269.         break;
  270.     case 24:
  271.         color24 = c;
  272.         break;
  273.     }
  274. }
  275.  
  276. void*
  277. get_frame_buffer_address()
  278. {
  279.     return image_mem;
  280. }
  281.  
  282. long
  283. get_frame_buffer_width()
  284. {
  285.     return default_size;
  286. }
  287.  
  288. long
  289. get_frame_buffer_height()
  290. {
  291.     if (mode)
  292.         return default_size >> 1;
  293.     else
  294.         return default_size;
  295. }
  296.  
  297. long
  298. get_frame_buffer_depth()
  299. {
  300.     return default_depth;
  301. }
  302.  
  303. long
  304. get_frame_buffer_pixel()
  305. {
  306.     return default_pixel;
  307. }
  308.  
  309. static void 
  310. do_update_screen8()
  311. {
  312. #define COPY_PIXEL(s, d)    *d++ = *s++
  313.  
  314.     register long rows, cols;
  315.     register PIXEL24 *s, *d;
  316.     register long diff_d;
  317.     register long extra;
  318.     register long size;
  319.  
  320.     s = (PIXEL24*) get_frame_buffer_address();
  321.     d = (PIXEL24*) screen_mem;
  322.  
  323.     if (mode)
  324.         diff_d = ((screen_width - get_frame_buffer_width()) >> 2) + (screen_width >> 2);
  325.     else
  326.         diff_d = ((screen_width - get_frame_buffer_width()) >> 2);
  327.  
  328.     size = get_frame_buffer_width() >> 2;
  329.     extra = size & 0xF;
  330.     size >>= 4;
  331.  
  332.     rows = get_frame_buffer_height();
  333.     while (rows--)
  334.     {
  335.         cols = size;
  336.  
  337.         switch (extra)
  338.         {
  339.             do {
  340.                 COPY_PIXEL(s, d);
  341.             case 15:
  342.                 COPY_PIXEL(s, d);
  343.             case 14:
  344.                 COPY_PIXEL(s, d);
  345.             case 13:
  346.                 COPY_PIXEL(s, d);
  347.             case 12:
  348.                 COPY_PIXEL(s, d);
  349.             case 11:
  350.                 COPY_PIXEL(s, d);
  351.             case 10:
  352.                 COPY_PIXEL(s, d);
  353.             case 9:
  354.                 COPY_PIXEL(s, d);
  355.             case 8:
  356.                 COPY_PIXEL(s, d);
  357.             case 7:
  358.                 COPY_PIXEL(s, d);
  359.             case 6:
  360.                 COPY_PIXEL(s, d);
  361.             case 5:
  362.                 COPY_PIXEL(s, d);
  363.             case 4:
  364.                 COPY_PIXEL(s, d);
  365.             case 3:
  366.                 COPY_PIXEL(s, d);
  367.             case 2:
  368.                 COPY_PIXEL(s, d);
  369.             case 1:
  370.                 COPY_PIXEL(s, d);
  371.             case 0:
  372.                 ;
  373.             }
  374.             while (cols--);
  375.         }
  376.  
  377.         d += diff_d;
  378.     }
  379. }
  380.  
  381. static void 
  382. do_update_screen24()
  383. {
  384. }
  385.  
  386. static void
  387. do_clear_frame_buffer8()
  388. {
  389.     register long rows, cols;
  390.     register PIXEL24 *p, c;
  391.     register long size;
  392.     register long extra;
  393.  
  394.     p = (PIXEL24*) get_frame_buffer_address();
  395.     c = color8;
  396.     c += c << 8;
  397.     c += c << 16;
  398.  
  399.     size = get_frame_buffer_width() >> 2;
  400.     extra = size & 0x1F;
  401.     size >>= 5;
  402.  
  403.     rows = get_frame_buffer_height();
  404.     while (rows--)
  405.     {
  406.         cols = size;
  407.  
  408.         switch (extra)
  409.         {
  410.             do {
  411.                 *p++ = c;
  412.             case 31:
  413.                 *p++ = c;
  414.             case 30:
  415.                 *p++ = c;
  416.             case 29:
  417.                 *p++ = c;
  418.             case 28:
  419.                 *p++ = c;
  420.             case 27:
  421.                 *p++ = c;
  422.             case 26:
  423.                 *p++ = c;
  424.             case 25:
  425.                 *p++ = c;
  426.             case 24:
  427.                 *p++ = c;
  428.             case 23:
  429.                 *p++ = c;
  430.             case 22:
  431.                 *p++ = c;
  432.             case 21:
  433.                 *p++ = c;
  434.             case 20:
  435.                 *p++ = c;
  436.             case 19:
  437.                 *p++ = c;
  438.             case 18:
  439.                 *p++ = c;
  440.             case 17:
  441.                 *p++ = c;
  442.             case 16:
  443.                 *p++ = c;
  444.             case 15:
  445.                 *p++ = c;
  446.             case 14:
  447.                 *p++ = c;
  448.             case 13:
  449.                 *p++ = c;
  450.             case 12:
  451.                 *p++ = c;
  452.             case 11:
  453.                 *p++ = c;
  454.             case 10:
  455.                 *p++ = c;
  456.             case 9:
  457.                 *p++ = c;
  458.             case 8:
  459.                 *p++ = c;
  460.             case 7:
  461.                 *p++ = c;
  462.             case 6:
  463.                 *p++ = c;
  464.             case 5:
  465.                 *p++ = c;
  466.             case 4:
  467.                 *p++ = c;
  468.             case 3:
  469.                 *p++ = c;
  470.             case 2:
  471.                 *p++ = c;
  472.             case 1:
  473.                 *p++ = c;
  474.             case 0:
  475.                 ;
  476.             }
  477.             while (cols--);
  478.         }
  479.     }
  480. }
  481.  
  482. static void
  483. do_clear_frame_buffer24()
  484. {
  485. }
  486.